import { defineStore } from "pinia";
import ConfigAPI from "@/api/system/config.api.js";
import SysTextAPI from "@/api/system/sys-text.api";

export const useConfigStore = defineStore("config", {
  state: () => ({
    // 配置数据缓存
    configMap: new Map(),
    loaded: false,
    loading: false,
    // 价格损耗数据缓存
    priceLossData: null,
    priceLossLoading: false,
    priceLossLoaded: false,
  }),

  getters: {
    /**
     * 获取指定key的配置值
     * @param {string} key - 配置键
     */
    getConfigValue: (state) => (key) => {
      return state.configMap.get(key) || null;
    },

    /**
     * 获取机印价格比例映射配置
     * 格式：10000-40,15000-20,999999-15
     * 表示小于等于该值时使用的比例
     */
    getMechanicalPriceMap: (state) => {
      if (!state.priceLossData) return [];

      try {
        // 解析新的JSON格式
        const configData = JSON.parse(state.priceLossData);
        const quantityLoss = configData.quantity || [];

        return quantityLoss
          .map((item) => ({
            quantity: parseInt(item.num || item.quantity),
            ratio: parseFloat(item.val || item.lossPercentage),
          }))
          .sort((a, b) => a.quantity - b.quantity);
      } catch (error) {
        console.error("解析价格损耗数据失败:", error);
        return [];
      }
    },

    /**
     * 根据数量获取对应的价格比例
     * @param {number} quantity 数量
     * @returns {number} 价格比例
     */
    getPriceRatioByQuantity: (state) => (quantity) => {
      if (!state.priceLossData) return 15; // 默认比例

      try {
        // 解析新的JSON格式
        const configData = JSON.parse(state.priceLossData);
        const quantityLoss = configData.quantity || [];

        const priceMap = quantityLoss
          .map((item) => ({
            quantity: parseInt(item.num || item.quantity),
            ratio: parseFloat(item.val || item.lossPercentage),
          }))
          .sort((a, b) => a.quantity - b.quantity);

        for (const item of priceMap) {
          if (quantity < item.quantity) {
            return item.ratio;
          }
        }

        // 如果数量超过所有配置的上限，使用最后一个配置的比例
        return priceMap.length > 0 ? priceMap[priceMap.length - 1].ratio : 15;
      } catch (error) {
        console.error("解析价格损耗数据失败:", error);
        return 15;
      }
    },

    /**
     * 根据价格获取对应的损耗比例
     * @param {number} price 价格
     * @returns {number} 损耗比例
     */
    getPriceLossByPrice: (state) => (price) => {
      if (!state.priceLossData) return 0; // 默认损耗

      try {
        // 解析新的JSON格式
        const configData = JSON.parse(state.priceLossData);
        const priceLoss = configData.price || [];
        const priceMap = priceLoss
          .map((item) => ({
            price: parseFloat(item.num || item.price),
            loss: parseFloat(item.val || item.lossPercentage),
          }))
          .sort((a, b) => a.price - b.price);

        for (const item of priceMap) {
          if (price < item.price) {
            return item.loss;
          }
        }

        // 如果价格超过所有配置的上限，使用最后一个配置的损耗
        return priceMap.length > 0 ? priceMap[priceMap.length - 1].loss : 0;
      } catch (error) {
        console.error("解析价格损耗数据失败:", error);
        return 0;
      }
    },

    getBagPrice: (state) => {
      const value = state.configMap.get("BAG_PRICE");
      return value ? parseFloat(value) : 0;
    },

    /**
     * 获取订单类型配置
     * @returns {Array} 订单类型列表
     */
    getOrderTypes: () => {
      return [
        { label: "机印", value: 0 },
        { label: "现货数码印", value: 1 },
        { label: "定制数码印", value: 2 },
        { label: "单层袋印", value: 3 },
        { label: "机印2", value: 4 },
        { label: "其他类型", value: 5 },
      ];
    },

    /**
     * 根据类型值获取类型标签
     * @param {number} type - 类型值
     * @returns {string} 类型标签
     */
    getOrderTypeLabel: () => (type) => {
      const types = {
        0: "机印",
        1: "现货数码印",
        2: "定制数码印",
        3: "单层袋印",
        4: "机印2",
        5: "其他类型",
      };
      return types[type] || "其他";
    },

    /**
     * 获取订单状态配置
     * @returns {Array} 订单状态列表
     */
    getOrderStatuses: () => {
      return [
        { label: "待处理", value: 0, type: "warning" },
        { label: "处理中", value: 3, type: "primary" },
        { label: "已处理", value: 1, type: "success" },
        { label: "已确定", value: 2, type: "info" },
      ];
    },

    /**
     * 根据状态值获取状态标签
     * @param {number} status - 状态值
     * @returns {string} 状态标签
     */
    getOrderStatusLabel: () => (status) => {
      const statuses = {
        0: "待处理",
        3: "处理中",
        1: "已处理",
        2: "已确定",
      };
      return statuses[status] || "-";
    },

    /**
     * 根据状态值获取状态标签类型
     * @param {number} status - 状态值
     * @returns {string} 状态标签类型
     */
    getOrderStatusType: () => (status) => {
      const statusTypes = {
        0: "warning", // 待处理 - 橙色
        1: "success", // 已处理 - 绿色
        2: "info", // 已关闭 - 灰色
        3: "primary", // 已确定 - 蓝色
      };
      return statusTypes[status] || "";
    },
  },

  actions: {
    /**
     * 从 localStorage 加载价格损耗数据缓存
     */
    loadPriceLossCacheData() {
      try {
        const cachedData = localStorage.getItem("price_loss_data");
        const cachedUpdateTime = localStorage.getItem("price_loss_update_time");

        if (!cachedData || !cachedUpdateTime) {
          console.log("价格损耗缓存: 无缓存数据");
          return false;
        }

        // 解析缓存数据
        this.priceLossData = cachedData;
        console.log("价格损耗缓存: 从缓存加载数据成功", cachedData);
        return true;
      } catch (error) {
        console.error("价格损耗缓存: 加载缓存失败:", error);
        this.clearPriceLossCache();
        return false;
      }
    },

    /**
     * 检查是否有价格损耗缓存数据
     */
    hasPriceLossCacheData() {
      try {
        const cachedData = localStorage.getItem("price_loss_data");
        return !!cachedData;
      } catch {
        return false;
      }
    },

    /**
     * 保存价格损耗数据到 localStorage
     */
    savePriceLossCacheData(data) {
      try {
        localStorage.setItem("price_loss_data", data);
        localStorage.setItem("price_loss_update_time", new Date().toLocaleString());
        console.log("价格损耗缓存: 保存到缓存成功");
      } catch (error) {
        console.error("价格损耗缓存: 保存到缓存失败:", error);
      }
    },

    /**
     * 清空价格损耗缓存
     */
    clearPriceLossCache() {
      this.priceLossData = null;
      this.priceLossLoaded = false;
      this.priceLossLoading = false;

      try {
        localStorage.removeItem("price_loss_data");
        localStorage.removeItem("price_loss_update_time");
        console.log("价格损耗缓存: 清除缓存成功");
      } catch (error) {
        console.error("价格损耗缓存: 清除缓存失败:", error);
      }
    },

    /**
     * 加载价格损耗数据
     */
    async loadPriceLossData() {
      if (this.priceLossLoaded) {
        return this.priceLossData;
      }
      if (this.priceLossLoading) {
        // 如果正在加载，等待加载完成
        while (this.priceLossLoading) {
          await new Promise((resolve) => setTimeout(resolve, 100));
        }
        return this.priceLossData;
      }

      // 检查是否有缓存数据
      if (this.hasPriceLossCacheData()) {
        // 有缓存数据，立即加载并返回
        const hasCachedData = this.loadPriceLossCacheData();
        if (hasCachedData) {
          console.log("价格损耗数据: 使用缓存数据，立即返回");
          this.priceLossLoaded = true;

          // 在后台异步更新数据
          this.updatePriceLossDataInBackground();

          return this.priceLossData;
        }
      }

      // 没有缓存数据，需要同步加载
      this.priceLossLoading = true;

      try {
        console.log("价格损耗数据: 没有缓存数据，从接口获取数据");
        const response = await SysTextAPI.getTextByKey("price_loss_new");

        if (response) {
          this.priceLossData = response;
          console.log("价格损耗数据: 从接口加载成功", response);
        } else {
          // 如果没有数据，使用默认值（新JSON格式）
          const defaultData = {
            quantity: [
              { num: 10000, val: 40 },
              { num: 15000, val: 20 },
              { num: 999999, val: 15 },
            ],
            price: [
              { num: 10000, val: 10 },
              { num: 20000, val: 5 },
              { num: 999999, val: 2 },
            ],
          };
          this.priceLossData = JSON.stringify(defaultData);
          console.log("价格损耗数据: 使用默认值", this.priceLossData);
        }

        // 保存到缓存
        this.savePriceLossCacheData(this.priceLossData);

        this.priceLossLoaded = true;
        return this.priceLossData;
      } catch (error) {
        console.error("价格损耗数据: 从接口加载失败:", error);
        // 使用默认值（新JSON格式）
        const defaultData = {
          quantity: [
            { num: 10000, val: 40 },
            { num: 15000, val: 20 },
            { num: 999999, val: 15 },
          ],
          price: [
            { num: 10000, val: 10 },
            { num: 20000, val: 5 },
            { num: 999999, val: 2 },
          ],
        };
        this.priceLossData = JSON.stringify(defaultData);

        // 保存默认值到缓存
        this.savePriceLossCacheData(this.priceLossData);

        return this.priceLossData;
      } finally {
        this.priceLossLoading = false;
      }
    },

    /**
     * 在后台异步更新价格损耗数据
     */
    async updatePriceLossDataInBackground() {
      try {
        console.log("价格损耗数据更新: 后台获取最新数据");
        const response = await SysTextAPI.getTextByKey("price_loss_new");

        if (response) {
          this.priceLossData = response;
          console.log("价格损耗数据更新: 后台更新成功", response);
        } else {
          // 如果没有数据，使用默认值（新JSON格式）
          const defaultData = {
            quantity: [
              { num: 10000, val: 40 },
              { num: 15000, val: 20 },
              { num: 999999, val: 15 },
            ],
            price: [
              { num: 10000, val: 10 },
              { num: 20000, val: 5 },
              { num: 999999, val: 2 },
            ],
          };
          this.priceLossData = JSON.stringify(defaultData);
          console.log("价格损耗数据更新: 使用默认值", this.priceLossData);
        }

        // 保存到缓存
        this.savePriceLossCacheData(this.priceLossData);
      } catch (error) {
        console.error("价格损耗数据更新: 后台更新失败:", error);
      }
    },

    /**
     * 刷新价格损耗数据
     */
    async refreshPriceLossData() {
      this.priceLossLoaded = false;
      this.priceLossData = null;
      return await this.loadPriceLossData();
    },

    /**
     * 从 localStorage 加载缓存的配置数据
     */
    loadCacheData() {
      try {
        const cachedData = localStorage.getItem("config_data");

        if (!cachedData) {
          console.log("配置缓存: 无缓存数据");
          return false;
        }

        // 解析缓存数据
        const configData = JSON.parse(cachedData);

        // 清空现有配置
        this.configMap.clear();

        // 加载缓存数据到 Map
        if (Array.isArray(configData)) {
          configData.forEach((config) => {
            if (config.configKey && config.configValue !== undefined) {
              this.configMap.set(config.configKey, config.configValue);
            }
          });
        }

        console.log("配置缓存: 从缓存加载配置数据成功", configData.length, "条配置");
        return true;
      } catch (error) {
        console.error("配置缓存: 加载缓存失败:", error);
        this.clearCache();
        return false;
      }
    },

    /**
     * 检查是否有缓存数据
     */
    hasCacheData() {
      try {
        const cachedData = localStorage.getItem("config_data");
        return !!cachedData;
      } catch {
        return false;
      }
    },

    /**
     * 保存配置数据到 localStorage
     */
    saveCacheData(configList) {
      try {
        localStorage.setItem("config_data", JSON.stringify(configList));
        console.log("配置缓存: 保存到缓存成功");
      } catch (error) {
        console.error("配置缓存: 保存到缓存失败:", error);
      }
    },

    /**
     * 加载配置数据
     */
    async loadConfigs() {
      if (this.loaded) {
        return this.configMap;
      }
      if (this.loading) {
        // 如果正在加载，等待加载完成
        while (this.loading) {
          await new Promise((resolve) => setTimeout(resolve, 100));
        }
        return this.configMap;
      }

      // 检查是否有缓存数据
      if (this.hasCacheData()) {
        // 有缓存数据，立即加载并返回
        const hasCachedData = this.loadCacheData();
        if (hasCachedData) {
          console.log("配置加载: 使用缓存数据，立即返回");
          this.loaded = true;

          // 在后台异步更新数据
          this.updateDataInBackground();

          return this.configMap;
        }
      }

      // 没有缓存数据，需要同步加载
      this.loading = true;

      try {
        console.log("配置加载: 没有缓存数据，从接口获取数据");
        const response = await ConfigAPI.getPage({ size: 1000 });

        // 清空现有配置
        this.configMap.clear();

        // 将配置数据转换为Map存储
        if (response.list && Array.isArray(response.list)) {
          response.list.forEach((config) => {
            if (config.configKey && config.configValue !== undefined) {
              this.configMap.set(config.configKey, config.configValue);
            }
          });

          // 保存到缓存
          this.saveCacheData(response.list);
        }

        this.loaded = true;
        console.log("配置加载: 从接口加载配置数据成功", response.list?.length || 0, "条配置");
        return this.configMap;
      } catch (error) {
        console.error("配置加载: 从接口加载失败:", error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    /**
     * 在后台异步更新数据
     */
    async updateDataInBackground() {
      try {
        console.log("配置更新: 后台获取最新数据");
        const response = await ConfigAPI.getPage({ size: 1000 });

        // 清空现有配置
        this.configMap.clear();

        // 将配置数据转换为Map存储
        if (response.list && Array.isArray(response.list)) {
          response.list.forEach((config) => {
            if (config.configKey && config.configValue !== undefined) {
              this.configMap.set(config.configKey, config.configValue);
            }
          });

          // 保存到缓存
          this.saveCacheData(response.list);
        }

        console.log("配置更新: 后台更新配置数据成功", response.list?.length || 0, "条配置");
      } catch (error) {
        console.error("配置更新: 后台更新失败:", error);
      }
    },

    /**
     * 刷新配置缓存
     */
    async refreshConfigs() {
      this.loaded = false;
      this.configMap.clear();
      return await this.loadConfigs();
    },

    /**
     * 清空缓存（包括内存和 localStorage）
     */
    clearCache() {
      // 清空内存数据
      this.configMap.clear();
      this.loaded = false;
      this.loading = false;

      // 清除 localStorage 缓存
      try {
        localStorage.removeItem("config_data");
        console.log("配置缓存: 清除所有缓存成功");
      } catch (error) {
        console.error("配置缓存: 清除 localStorage 缓存失败:", error);
      }
    },
  },
});
